package com.jz.netthings.netty.decode;

import com.jz.netthings.netty.support.Attributes;
import com.jz.netthings.netty.protocol.bean.ZxdcLoginPacket;
import com.jz.netthings.netty.utils.NettyMsgHelper;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import io.netty.util.CharsetUtil;

import java.util.List;

public class NettyZxdcDecoder extends ByteToMessageDecoder {

    private static final int LOGIN_PACKET_LEN = 4 + 4 + 4 + 4 + 3 + 4 + 1 + 4 + 1;//单采机登录请求包的长度  29 个长度：消息头 + 连接客户端类型 + 数据格式 + 应用编码的长度 + ...
    private static final int MSG_PACKET_LEN = 4 + 4;//单采机其他消息包的基本  8 个长度 ：消息头 + 消息长度

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf buffer, List<Object> out) throws Exception {

//        System.out.println("长度：" + buffer.readableBytes());
        // 可读长度必须大于基本长度
        if (buffer.readableBytes() >= MSG_PACKET_LEN) {

            // 记录包头开始的index
            int beginReader;
            int res_code = -1;
            while (true) {
                // 获取包头开始的index
                beginReader = buffer.readerIndex();
                // 标记包头开始的index
                buffer.markReaderIndex();
                // 读到了协议的开始标志，结束while循环
                res_code = buffer.readInt();
                if (res_code == Attributes.LOGIN_RES_CODE || res_code == Attributes.MSG_RES_CODE) {
                    break;
                }

                // 未读到包头，略过一个字节
                // 每次略过，一个字节，去读取，包头信息的开始标记
                buffer.resetReaderIndex();
                buffer.readByte();

                // 当略过，一个字节之后，
                // 数据包的长度，又变得不满足
                // 此时，应该结束。等待后面的数据到达
                if (buffer.readableBytes() < MSG_PACKET_LEN) {
                    return;
                }
            }

            if (res_code == Attributes.LOGIN_RES_CODE) {
                //是登录的消息头
                if (buffer.readableBytes() < (LOGIN_PACKET_LEN - 4)) {
                    //证明消息头后面的消息长度都不够
                    // 还原读指针
                    buffer.readerIndex(beginReader);
                    return;
                }else {
                    ZxdcLoginPacket loginPacket = NettyMsgHelper.buildRequestLoginPacket(res_code, buffer);

                    out.add(loginPacket);
                }



            }else if(res_code == Attributes.MSG_RES_CODE){
                // 消息的长度

                int length = buffer.readInt();
                // 判断请求数据包数据是否到齐
                if (buffer.readableBytes() < length) {
                    // 还原读指针
                    buffer.readerIndex(beginReader);
                    return;
                }

                // 读取data数据
                byte[] data = new byte[length];
                buffer.readBytes(data);

                out.add(data);
            }

        } else {
            return;
        }


    }
}

/*
{

        //F3B6
        System.out.println("长度："+msg.readableBytes());

        if (msg.readableBytes() == 4){
            msg.markReaderIndex();
            int res_code = msg.readInt();
            System.out.println("---------------["+res_code+"]");
            msg.resetReaderIndex();
        }
        if (msg.readableBytes() < MSG_PACKET_LEN) {
            //半包
            return;
        }
        System.out.println("内容：【"+msg.toString(CharsetUtil.US_ASCII)+"】");
        //把当前的读指针保存起来
        msg.markReaderIndex();
        // 获取消息头
        int res_code = msg.readInt();
        boolean flag = false;
//        while (msg.isReadable()){
        while(msg.readableBytes() >= 0){
            if(res_code == Attributes.LOGIN_RES_CODE || res_code ==  Attributes.MSG_RES_CODE){
                flag = true;
                 break;
            }else{
                if (msg.readableBytes() >= 4){
                    res_code = msg.readInt();
                }
            }
        }
//        msg.resetReaderIndex();
        if (flag){
            //读取到了消息头
            if(res_code == Attributes.LOGIN_RES_CODE){
                //是登录的消息头
                if (msg.readableBytes() < (LOGIN_PACKET_LEN - 4)) {
                    //证明消息头后面的消息长度都不够
                    msg.resetReaderIndex();
                    return;
                }else{
                    ZxdcLoginPacket packet = new ZxdcLoginPacket();

                    packet.setResCode(res_code);
                    packet.setClientType(msg.readInt());
                    packet.setMsgFormat(msg.readInt());

                    int apCodeLen = msg.readInt();
                    byte[] apCode = new byte[apCodeLen];
                    msg.readBytes(apCode);//应用编码（ApCode）
                    packet.setApCode(new String(apCode, CharsetUtil.US_ASCII));

                    int OrgCodeLen = msg.readInt();
                    byte[] orgCode = new byte[OrgCodeLen];
                    msg.readBytes(orgCode);//应用所属组织（OrgCode）
                    packet.setOrgCode(new String(orgCode, CharsetUtil.US_ASCII));

                    int loginPwdLen = msg.readInt();
                    byte[] loginPwd = new byte[loginPwdLen];
                    msg.readBytes(loginPwd);//登录密码
                    packet.setPwd(new String(loginPwd, CharsetUtil.US_ASCII));

                    out.add(packet);
                    msg.resetReaderIndex();
                }
            }else {
                //是后期信息的消息头
                if (msg.readableBytes() < 4) {
                    //证明消息头后面的消息长度都不够
                    msg.resetReaderIndex();
                    return;
                }else {
//                    msg.readInt();//消息头
                    int length = msg.readInt();//消息长度
                    if (msg.readableBytes() < length) {
                        //后面的数据长度没有达到消息长度
                        msg.resetReaderIndex();
                        return;
                    }else{
                        //大于、等于长度
                        // 读取data数据
                        byte[] data = new byte[length];
                        msg.readBytes(data);

                        out.add(data);
                        msg.resetReaderIndex();
                    }
                }
            }
            msg.skipBytes(msg.readableBytes());
        }else{
            //没有读到消息头
            msg.resetReaderIndex();
            return;
        }




    }
 */
